package cn.biplam.common.tools;

import java.io.FileInputStream;
import java.io.IOException;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.Enumeration;
import java.util.List;
import java.util.Properties;
import java.util.Random;
import java.util.regex.Pattern;

import cn.biplam.common.client.Log;
import cn.biplam.common.client.OperatorResult;
import cn.biplam.common.client.Log.Log_Level;
import cn.biplam.common.wrapper.ErrorMessage;
import cn.biplam.common.wrapper.KvMap;
import cn.biplam.common.wrapper.sqlresult.SqlResult;
import cn.biplam.common.wrapper.sqlresult.SqlResultMetaData;

/**
 * 工具类
 */
public abstract class TOOLS {

	/**
	 * 取系统ip地址
	 * @return  String
	 */
	public static String getIp(){
		String ip = "";
		try {
			InetAddress addr = InetAddress.getLocalHost();
			ip = addr.getHostAddress().toString();//获得本机IP
		} catch (UnknownHostException e) {
			e.printStackTrace();
		}    
		return ip;
	}

	/**
	 * 在传入的文件路径下,创建以当天8位日期命名的目录
	 * @param sPath			文件路径
	 * @return	String
	 * @throws ErrorMessage
	 */
	public static String createDailyDir(String sPath) throws ErrorMessage{
		Date d = new Date();
		SimpleDateFormat sf = new SimpleDateFormat("yyyyMMdd");
		String dirname = sf.format(d);
		StringBuilder sb = new StringBuilder(sPath);
		if(!sPath.endsWith("/")){
			sb.append("/");
		}
		sb.append(dirname);
		sb.append("/");
		String dirpath=sb.toString();
		java.io.File dir=new java.io.File(dirpath);
		if (!dir.isDirectory()){
			dir.mkdirs();
			if(!dir.isDirectory()) {
				throw new ErrorMessage("Create directory failed!");
			}
		}
		return dirpath;
	}

	/**
	 * 以系统时间创建精确到每秒的随机文件名
	 * @return	String
	 * @throws ErrorMessage
	 */
	public static String getSecondFileName() throws ErrorMessage{
		Date d = new Date();
		SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");
		return sdf.format(d);
	}

	/**
	 * 以系统时间创建每天唯一的文件名(当天到秒的时间)
	 * @return	String
	 * @throws ErrorMessage
	 */
	public static String getDailyFileName() throws ErrorMessage{
		Date d = new Date();
		SimpleDateFormat sdf = new SimpleDateFormat("HHmmss");
		return sdf.format(d);
	}

	/**
	 * 字符串转换成整数
	 * @param   s  要转换的字符串
	 * @return	int
	 */
	public static int stringToInt(String s){
		int i = -1;
		if(s!=null && !"".equals(s.trim()) && !"null".equals(s.trim())){
			if(isNumeric(s)){
				i = Integer.parseInt(s);
			}
		}
		return i;
	}

	/**
	 * 字符串转换成整数
	 * @param   s  要转换的字符串
	 * @return	int
	 */
	public static int stringToBigInt(String s){
		int i = -9999;
		if(s!=null && !"".equals(s.trim()) && !"null".equals(s.trim())){
			if(isNumeric(s)){
				i = Integer.parseInt(s);
			}
		}
		return i;
	}

	/**
	 * 字符串转换成 char
	 * @param str
	 * @return	char
	 * @throws ErrorMessage
	 */
	public static char stringToChar(String str) throws ErrorMessage{
		char c = '2';
		if(str!=null && !str.trim().equals("")){
			c = str.toCharArray()[0]; 
		}else{
			throw new ErrorMessage(" String to char Error ");
		}
		return c;
	}

	/**
	 * 字符串转换成double
	 * @param   s  要转换的字符串
	 * @return	double
	 */
	public static double stringToDouble(String s){
		double i = -1;
		if(s!=null && !"".equals(s.trim()) && !"null".equals(s.trim())){
			try{
				i = Double.parseDouble(s);
			}catch(Exception e){}
		}
		return i;
	}

	/**
	 * 字符串转换成double
	 * @param   s  要转换的字符串
	 * @return	double
	 */
	public static float stringToFloat(String s){
		float i = -1;
		if(s!=null && !"".equals(s.trim()) && !"null".equals(s.trim())){
			try{
				i = Float.parseFloat(s);
			}catch(Exception e){}
		}
		return i;
	}

	/**
	 * 将字符串转换为布尔值 value="1"时为true，其它为false
	 * @param value
	 * @return	boolean
	 */
	public static boolean stringToBoolean(String value){
		return "1".equals(value)?true:false;
	}

	/**
	 * String null to empty
	 * @param s 要处理的字符串 
	 * @return String
	 */
	public static String stringNullToEmpty(String s){
		if(s==null || "null".equals(s.trim())){
			s="";
		}else{
			s = s.trim();
		}
		return s;
	}

	/**
	 * 用括号把字符串括起来，如果字符串为空返回空字符串, 如："名称" 返回 "(名称)"
	 * @param s
	 * @return 用括号把字符串括起来
	 */
	public static String getBracketDesc(String s){
		String desc = "";
		if(!TOOLS.StringIsEmpty(s)){
			desc = "("+TOOLS.stringNullToEmpty(s)+")";
		}
		return desc;
	}

	/**
	 * 判断字符串是否是数字
	 * @param 	str  字符串
	 * @return boolean
	 */
	public static boolean isNumeric(String str){ 
		Pattern pattern = Pattern.compile("[0-9]*"); 
		return pattern.matcher(str).matches();    
	}

	/**
	 * 判断字符串是否是10位日期
	 * @param str
	 * @return boolean
	 */
	public static boolean isDate10(String str){
		Pattern pattern = Pattern.compile("[0-9][0-9][0-9][0-9]-[0-1][0-9]-[0-3][0-9]"); 
		return pattern.matcher(str).matches();    
	}

	/**
	 * 判断字符串是否是10位日期
	 * @param str
	 * @return boolean
	 */
	public static boolean isDate8(String str){
		Pattern pattern = Pattern.compile("[0-9][0-9][0-9][0-9][0-1][0-9][0-3][0-9]"); 
		return pattern.matcher(str).matches();    
	}

	/**
	 * 将时间格式化成短日期格式yyyy-MM-dd
	 * @param dt
	 * @return String
	 */
	public static String formatDate(Date dt){
		return formatDate(dt, "yyyy-MM-dd");
	}

	/**
	 * 按指定日期格式转换日期字符串
	 * @param dt
	 * @param pattern
	 * @return String
	 */
	public static String formatDate(Date dt,String pattern){
		SimpleDateFormat df=new SimpleDateFormat(pattern);
		return df.format(dt);
	}

	/**
	 * 返回格式化成功的日期字符串(多的月份进位到年,多的天数进位到月)<BR>
	 * 如果要严格匹配,先调用isDate检查
	 * @param dt	yyyy-MM-dd
	 * @return String
	 */
	public static String formatDate(String dt){
		SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
		try {
			return df.format(df.parse(dt));
		} catch (ParseException e) {
			return "0000-00-00";
		}
	}

	/**
	 * 采用Properties类取得属性文件对应值
	 *@param propertiesFileNameproperties文件名，如a.properties
	 *@param propertyName属性名
	 *@return 根据属性名得到的属性值，如没有返回null
	 * @throws ErrorMessage 
	 */
	public static String getValueByPropertyName(String propertiesFileName,String propertyName) throws ErrorMessage {
		String s;
		Properties p=new Properties();//加载属性文件读取类
		String path = Thread.currentThread().getContextClassLoader().getResource("").getPath();
		try {
			p.load(new FileInputStream(path+propertiesFileName));
			s=p.getProperty(propertyName);//取得对应的属性值
		} catch (IOException e) {
			ErrorMessage mErrorMessage = new ErrorMessage(e,propertiesFileName);
			throw mErrorMessage;
		}
		return s;
	}
	/**
	 * 功能 		取Properties文件的所有key-value
	 *@param 	propertiesFileNameproperties文件名，如a.properties
	 *@param 	propertyName属性名
	 *@return 	属性值集合的KvMap，如没有返回空的KvMap
	 * @throws ErrorMessage 
	 */
	@SuppressWarnings("unchecked")
	public static KvMap<String,String> getValueByProperty(String propertiesFileName) throws ErrorMessage {

		KvMap<String,String> kvPro = new KvMap<String,String>();
		Properties p=new Properties();//加载属性文件读取类
		String path = Thread.currentThread().getContextClassLoader().getResource("").getPath();
		try {
			p.load(new FileInputStream(path+propertiesFileName));
			Enumeration e = (Enumeration)p.propertyNames();
			while(e.hasMoreElements()){
				String key = (String)e.nextElement();
				kvPro.put(key, getValueByPropertyName(propertiesFileName, key));
			}
		} catch (IOException e) {
			throw new ErrorMessage(e);
		} 

		return kvPro;
	}

	/**
	 * 字符串替换substr([char],[m],[n])
	 * @param str      字符串          substr([char],[m],[n])
	 * @param paramName需要替换的字符串  m
	 * @param flag1    字符串包围标识    [
	 * @param flag2    字符串包围标识    ]
	 * @param replace  替换成的字符串    123
	 * @return String
	 */
	public static String strReaplace(String str,String paramName,String flag1,String flag2,String replace){
		str = str.replace(flag1+paramName+flag2, replace);
		return str;
	}

	/**
	 * 功能   字符串参数替换
	 * @param sParamStr  需替换参数的字符串
	 * @param kvParam    参数列表
	 * @param sflag      参数标识
	 * @param sflag1     参数间分隔符
	 * @return String
	 */
	public static String paramReaplace(String srule,String sParamStr,KvMap<String,String> kvParam,String sflag,String sflag1){

		String[] aParam = null;
		/**取出参数字符串*/

		if(sParamStr != null && !sParamStr.trim().equals("")){
			aParam = sParamStr.split(sflag1);
			/**替换参数字符串*/
			for(int i=0;i<aParam.length;i++){
				srule = srule.replace(sflag+aParam[i]+sflag, kvParam.getByKey(aParam[i]));
			}
		}
		return srule;
	}

	/**
	 * 功能  把字符串中的参数分离出来
	 * @param str 需要分离的带参数的字符串
	 * @param flag 参数包围符
	 * @return String[]
	 */
	public static String[] paramSplit(String s,String flag){

		String ss = "";

		int end = -1;
		while(s.indexOf(flag)!=-1){
			s = s.substring(s.indexOf(flag)+1,s.length());   
			if(s.indexOf(flag)!=-1){
				end = s.indexOf(flag);   
				ss = ss + s.substring(0,end)+",";
				s = s.substring(end+1,s.length());
			}
		}
		if(ss.lastIndexOf(",")!=-1){
			ss = ss.substring(0,ss.lastIndexOf(","));
		}

		return ss.split(",");
	}

	/**
	 * 将布尔值转换成字符代码 如果是true 返回1 否则返回0
	 * @param value	
	 * @return String
	 */
	public static String booleanToString(boolean value){
		return value?"1":"0";
	}

	/**
	 * 整形转换成字符串型
	 * @param i
	 * @return
	 */
	public static String intToString(int i){
		return String.valueOf(i);
	}

	/**
	 * 功能 将空字符串转换成空对象
	 * @param str 空
	 * @return
	 */
	public static String changeEmptyToNull(String str){
		if(str==null||str.trim().equals("")){
			return null;
		}else{
			return str.trim();
		}
	}

	/**
	 * 功能 字符串转换成大写，如果为空返回空 
	 * @param str 字符串 
	 * @return
	 */
	public static String toUpper(String str){
		if(str==null){
			return null;
		}else{
			return str.toUpperCase();
		}
	}

	/**
	 * 功能 截取字符串的len个字符
	 * @param str 
	 * @param len
	 * @return
	 */
	public static String subString(String str,int len){
		int counter=0;
		StringBuilder sp=new StringBuilder();
		for(int i=0;i<str.length();i++){
			char c=str.charAt(i);
			if(c<255){
				counter++;
			}else{
				counter=counter+2;
			}
			if(counter>len){
				break;
			}
			sp.append(c);
		}
		return sp.toString();
	}

	/**
	 * 功能 获取字符串在字符串数组中的位置(目前采用顺序遍历法，可以改进为二分法)
	 * @param strArray  字符串数组
	 * @param str       字符串
	 * @return
	 */
	public static int getIndexOfString(String[] strArray,String str){
		int index=-1;
		for(int i=0;i<strArray.length;i++){
			if(str.equals(strArray[i])){
				index=i;
				break;
			}
		}
		return index;
	}

	/**
	 * 功能 将字符数组放入list
	 * @param list  列表
	 * @param array 字符数组
	 */
	public static void stringArrayToList(ArrayList<String> list,String...array){
		for(String ar:array){
			list.add(ar);
		}
	}

	/**
	 * 功能将数组对象放入list
	 * @param list  列表 
	 * @param array 数组
	 */
	public static void ArrayToList(ArrayList<Object> list,Object...array){
		for(Object ar:array){
			list.add(ar);
		}
	}

	/**
	 * 将String类型的ArrayList转换成一维String数组
	 * @param list 要转换的list
	 * @return list转换后的数组
	 */
	public static String[] listToStringArray(ArrayList<String> list){
		String[] sqlArray=new String[list.size()];
		for(int i=0;i<list.size();i++){
			sqlArray[i]=list.get(i);
		}
		return sqlArray;
	}

	/**
	 * 获取普通字符所占px宽度
	 * @param length
	 * @return	int
	 */
	public static int getPxLengthNorm(int length){
		return length*6;
	}

		
	/**
	 * 获取加粗字符所占px宽度
	 * @param length
	 * @return	int
	 */
	public static int getPxLength(int length){
		int px=length*7;
		switch(length){
		case 1:
			px+=3;
			break;
		case 2:
			px+=5;
			break;
		case 3:
			px+=4;
			break;
		case 4:
			px+=3;
			break;
		case 5:
			px+=2;
			break;
		case 6:
			px+=2;
			break;
		case 7:
			px+=3;
			break;
		case 8:
			px+=4;
			break;
		case 9:
			px+=3;
			break;
		case 10:
			px+=4;
			break;	
		case 11:
			px+=3;
			break;
		default:
			px+=5;
		break;
		}
		return px;
	}

	/**
	 * 获取字符串所占px
	 * @param str  字符串
	 * @return	int
	 */
	public static int getTextLength(String str){
		int length=0;
		if(str!=null&&!"".equals(str)){
			length=str.getBytes().length;
		}
		return getPxLength(length);
	}

	/**
	 * 在控制台打印顺序列表
	 * @param list
	 */
	public static void printList(List<String> list){
		if(list==null){
			DEBUG.println("List is null!");
			return;
		}
		for(String str:list){
			DEBUG.println(str);
		}
	}

	/**
	 * 在控制台打印顺序列表
	 * @param list
	 */
	public static void printList(String[] list){
		if(list==null){
			DEBUG.println("List is null!");
			return;
		}
		for(String str:list){
			DEBUG.println(str);
		}
	}

	/**
	 * 在控制台打印顺序列表
	 * @param list
	 */
	public static void printList(String[][] list){
		if(list==null){
			return;
		}
		for(String str[]:list){
			for(String s:str){
				DEBUG.print(s+",");
			}
			DEBUG.println("");
		}
	}

	/**
	 * 将指定的有序列表反向
	 * @param list
	 * @return
	 */
	public static ArrayList<String[]> reverseList(ArrayList<String[]> list){
		ArrayList<String[]> reverseList = new ArrayList<String[]>();
		if(list == null){
			return null;
		}else if(list.size()==0){
			return list;
		}
		for(int i=list.size()-1;i>-1;i--){
			reverseList.add(list.get(i));
		}
		return reverseList;
	}

	/**
	 * 列表转换成字符串(在列表值之间加入逗号)
	 * @param list 列表
	 * @return 字符串
	 */
	public static String listToString(ArrayList<String> list){
		if(list == null || list.size()<1) return null;
		StringBuilder sp = new StringBuilder();
		sp.append(list.get(0));
		if(list.size()>1){
			for(int i=1;i<list.size();i++){
				sp.append(",");
				sp.append(list.get(i));
			}
		}
		return sp.toString();
	}

	/**
	 * 列表转换成字符串(在列表值之间加入逗号)
	 * @param list 列表
	 * @return 字符串
	 */
	public static String oListToString(ArrayList<?> list){
		if(list == null || list.size()<1) return null;
		StringBuilder sp = new StringBuilder();
		sp.append(list.get(0));
		if(list.size()>1){
			for(int i=1;i<list.size();i++){
				sp.append(",");
				sp.append(list.get(i));
			}
		}
		return sp.toString();
	}

	/**
	 * 列表转换成字符串
	 * @param list 列表
	 * @return 字符串
	 */
	public static String listToStringKey(ArrayList<String> list){
		if(list == null) return null;
		StringBuilder sp = new StringBuilder();
		for(String value:list){
			sp.append(value);
		}
		return sp.toString();
	}

	/**
	 * 字符串分割，如 String = #aaa#bbb; 返回aaa
	 * @param str  需要分割的字符串
	 * @param flag 分割字符
	 * @return	String
	 */
	public static String StringSplit(String str,String flag){
		String s = null;
		if(str!=null &&  flag!=null){
			int begin = str.indexOf(flag);
			int end = str.lastIndexOf(flag);
			if(begin!=-1 && begin<end){
				s = str.substring(begin+flag.length(),end);
			}
		}
		return s;
	}

	/**
	 * 字符串分割，如 String = #aaa#bbb; 返回aaa
	 * @param str			需要分割的字符串
	 * @param flagBegin		开始符号
	 * @param flagEnd		结束符号
	 * @return	String
	 */
	public static String StringSplit(String str,String flagBegin,String flagEnd){
		String s = null;
		if(str!=null){
			int begin = 0;
			int end = str.length();
			if(flagBegin!=null){
				begin = str.indexOf(flagBegin)+flagBegin.length();
			}
			if(flagEnd!=null){
				end = str.lastIndexOf(flagEnd);
			}
			if(begin!=-1 && begin<end){
				s = str.substring(begin,end);
			}
		}
		return s;
	}

	/**
	 * 为分割字符串的每项加上单引号
	 * @param str	分隔字符串
	 * @param flag	分隔符
	 * @return	String
	 */
	public static String StringSplitToSingleQuote(String str,String flag){
		String[] aStr=str.split(flag);
		StringBuilder sb=null;
		if(aStr.length>0){
			sb = new StringBuilder();
			for(String ite:aStr){
				sb.append('\'');
				sb.append(ite);;
				sb.append('\'');
				sb.append(flag);
			}
			sb.delete(sb.length()-flag.length(), sb.length());
		}
		return sb!=null?sb.toString():null;
	}

	/**
	 * 拆分字符串,并去除分隔值的单引号(例如为sql in子句准备的值列表)
	 * @param str	分隔符分隔,有单引号的字符串
	 * @param flag	分隔符
	 * @return String[]
	 */
	public static String[] StringSplitRemoveSingleQuote(String str,String flag){
		String[] aStr=str.split(flag);
		String[] rt=new String[aStr.length];
		String ite;
		for(int i=0;i<aStr.length;i++){
			ite=aStr[i];
			rt[i]=ite.substring(1, ite.length()-1);
		}
		return rt;
	}

	/**
	 * 判断字符串是否为空
	 * @param str 字符串
	 * @return 字符串为空
	 */
	public static boolean StringIsEmpty(String str){
		if(str==null || "null".equals(str.trim()) || "".equals(str.trim())){
			return true;
		}else{
			return false;
		}
	}

	/**
	 * 判断字符串是否为空
	 * @param str 字符串
	 * @return 字符串为空
	 */
	public static boolean StringIsNull(String str){
		return str==null?true:false;
	}

	/**
	 * 判断对象信息是否存在
	 * @return	boolean
	 */
	public static boolean exist(OperatorResult sr){
		return (sr==null || sr.size()<=0)?false:true;
	}

	/**
	 * 判断对象信息是否存在
	 * @return	boolean
	 */
	public static boolean exist(SqlResult sr){
		return (sr==null || sr.size()<=0 )?false:true;
	}

	/**
	 * 字符数组转换成字符串
	 * @param charArray 字符数组
	 * @return	String
	 */
	public static String charArrayTOString(char[] charArray){
		StringBuilder sp = new StringBuilder();
		for(char ca:charArray){
			sp.append(ca);
		}
		return sp.toString();
	}

	/**
	 * 生成指定大小的零值数组
	 * @param size 数组大小
	 * @return	String
	 */
	public static String getZeroArray(int size){
		StringBuilder sp = new StringBuilder();
		for(int i=0;i<size;i++){
			sp.append('0');
		}
		return sp.toString();
	}

	/**
	 * 字符串数组增加内容
	 * @param arr   数组
	 * @param param 新字符串
	 * @return	String[]
	 */
	public static String[] strArrAdd(String[] arr,String param){
		String[] strArr = null;
		if(arr!=null){
			strArr = new String[arr.length+1];
			for(int i=0;i<arr.length;i++){
				strArr[i] = arr[i];
			}
			strArr[arr.length] = param;
		} else{
			strArr = new String[]{param};
		}
		return strArr;
	}

	/**
	 * 字符串长度检查，如果超出指定的最大长度截断字符串，抛出警告(2)级异常
	 * @param example    字符串
	 * @param maxLength  最大长度
	 * @param alertInfo  异常提示信息
	 * @return 不超过最大长度的字符串
	 * @throws ErrorMessage
	 */
	public static String stringLengthCheck(StringBuilder example,
			int maxLength,String alertInfo) throws ErrorMessage{
		return stringLengthCheck(example.toString(),maxLength,alertInfo);
	}

	/**
	 * 字符串长度检查，如果超出指定的最大长度截断字符串，抛出警告(2)级异常
	 * @param example    字符串
	 * @param maxLength  最大长度
	 * @param alertInfo  异常提示信息
	 * @return 不超过最大长度的字符串
	 * @throws ErrorMessage
	 */
	public static String stringLengthCheck(String example,
			int maxLength,String alertInfo) throws ErrorMessage{
		String str = null;
		if(example!=null){
			int size = example.toString().getBytes().length;
			if(size>maxLength){
				str =  TOOLS.subStrToByteLength(example.toString(),maxLength);
				StringBuilder msg = new StringBuilder();
				msg.append(alertInfo);
				Log.write(new ErrorMessage(msg.toString()), Log_Level.Debug);
			}else{
				str = example.toString();
			}
		}
		if(str == null){
			str = "";
		}
		return str;
	}

	/**
	 * 转化字符串为十六进制编码 
	 * @param s
	 * @return	String
	 */
	public static String toHexString(String s)       
	{       
		String str= " ";       
		for(int i=0;i<s.length();i++){
			int ch = (int)s.charAt(i);       
			String s4 = Integer.toHexString(ch);       
			str = str + s4;   
		}       
		return str;       
	}

	/**
	 * 将字符串为十六进制编码转换成普通字符串
	 * @param s 十六进制编码字符串
	 * @return String
	 */
	public static String decodeHexString(String s)       
	{       
		if(s == null)return s;
		StringBuilder sp = new StringBuilder();
		for(int i=0;i<s.length();i++){
			int ch = (int)s.charAt(i);       
			String s4 = String.valueOf(ch);       
			sp.append(s4); 
		}       
		return sp.toString();       
	}

	/**
	 * 将byte数组装换成String
	 * @param bStr byte数组
	 * @return String
	 */
	public static String byteToString(byte[] bStr){
		return new String(bStr);
	}

	/**
	 * 把字符串截取成指定字节大小(用于数据库的字段值大小空值)
	 * @param str      截取的字符串
	 * @param byteLength  字节大小
	 * @return	String
	 */
	public static String subStrToByteLength(String str,int byteLength){
		String subStr = null;
		if(str!=null){
			byte[] b = str.getBytes();
			/**处理byteLength*/
			if(byteLength==0){
				byteLength = b.length;
			}
			byte[] c = new byte[byteLength];
			for(int i=0;i<byteLength;i++){
				c[i] = b[i];
			}
			subStr = new String(c);
		}
		return subStr;
	}

	/**
	 * Double取2位小数(四舍五入)
	 * @param d
	 * @return	String
	 */
	public static String doubleFormat(double d)   {   
		DecimalFormat df = new DecimalFormat("0.##");   
		return df.format(d);                    
	}

	/**
	 * 按时间生成随机id 时间+随机数
	 * @return	String
	 */
	public static String getId(){
		SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmssSSS");
		String id = sdf.format(new Date());
		Random randomNumber = new Random();
		int i = Math.abs(randomNumber.nextInt())%100;
		id += "" + i;
		return id;
	}

	/**
	 * 获取ajx返回的选择框值
	 * @param params      数据容器
	 * @param sFieldName  选择框名称
	 * @param unCheckValue 非选择时的值
	 * @return	String
	 */
	public static String getCheckBoxValue(KvMap<String, String> params,
			String sFieldName,String unCheckValue){
		String value = params.getByKey(sFieldName+"value");
		if(value == null){
			return unCheckValue;
		}else{
			return value;
		}
	}

	/**
	 * 获取ajx返回的下拉框值
	 * @param params      数据容器
	 * @param sFieldName  选择框名称
	 * @return 当前下拉框选择的值
	 */
	public static String getSelectValue(KvMap<String, String> params,
			String sFieldName){
		String value = params.getByKey(sFieldName+"value");
		return value;
	}

	/**
	 * 返回字符串中指定的字符对的下标   如："#aaa#bbb#cccc#",按照字符"#"分隔后,返回的下标对为 [0,4] [8,13]
	 * @param str        要分隔的字符串
	 * @param splitChar  分隔符
	 * @return	ArrayList
	 */
	public static ArrayList<int[]> getSplitGroupIndex(String str,String splitChar){
		ArrayList<int[]> groups = new ArrayList<int[]>();
		int[] group;
		int first = str.indexOf(splitChar);
		int second;
		int i=0;
		while(first>-1){
			group = new int[2];
			second = str.indexOf(splitChar, first+1);
			group[0] = first;
			group[1] = second;
			if(i%2==0){
				groups.add(group);
			}
			first = second;
			i++;
		}
		return groups;
	}

	/**
	 * 插入到数据库前的字符处理
	 * @param str	字符串
	 * @return	String
	 */
	public static String stringToDbDeal(String str){
		if(str !=null){
			str = str.replaceAll("'","''");
			str = str.replaceAll("\n","<br>");
			str = str.replaceAll("\t","    ");
		}
		return str;
	}

	/**
	 * 删除指定字符串中的所有换行符
	 * @param str 字符串
	 * @return String
	 */
	public static String removeBreakLine(String str){
		//如果为空字符串返回
		if(str==null)return str;
		str = str.replace("\n", "");//删除换行符
		str = str.replace("\r", "");//删除回车符
		//返回删除换行字符串
		return str;
	}

	/**
	 * 将字符串中的换行符替换成空
	 * @param str	字符串
	 * @return	String
	 */
	public static String replaceBreakLineToNull(String str){
		if(str !=null){
			str = removeBreakLine(str);   //删除回车换行符
			str = str.replaceAll("\t","");//删除Tab符
			str = str.trim();
		}
		return str;
	}

	/**
	 * 从数据库读出后的字符处理(替换<br> <p> Tab)
	 * @param str	字符串
	 * @return	String
	 */
	public static String stringDecoceFromDb(String str){
		if(str !=null){
			str = str.replaceAll("<br>","\n");
			str = str.replaceAll("<p>","\n");
			str = str.replaceAll("    ","\t");
		}
		return str;
	}

	/**
	 * 设置SQL表达式,将表达式中的字段统一替换成 表名.字段名 如果原来有表名则不替换
	 * @param codeExp        表达式
	 * @param tableName  表名
	 * @param fieldName  字段名
	 * @return	String
	 */
	public static String changeExpFieldToTableField(String codeExp,String tableName,String fieldName){
		StringBuilder sp = new StringBuilder();
		String[] exp = codeExp.split(tableName+"\\.");
		for(String e:exp){
			sp.append(e.replace(fieldName, tableName+"."+fieldName));
		}
		return sp.toString();
	}

	/**
	 * 结果集转换为HtmlTable文本
	 * @param sr	查询结果集(含SqlResultMetaData)
	 * @return	String
	 * @throws ErrorMessage
	 */
	public static String getTable(SqlResult sr) throws ErrorMessage{
		StringBuilder sb = new StringBuilder();
		SqlResultMetaData md = null;
		if (sr != null && sr.size() > 0) {
			md = sr.getMetadata();
			sb.append("<table border='1'>\n");
			/**表头*/
			sb.append("<tr>\n");
			for(int i=0;i<md.getColumnCount();i++){
				sb.append("<td style='font-size:14'>");
				sb.append(md.getColumnNameByIndex(i));
				sb.append("</td>\n");
			}
			sb.append("</tr>\n");
			/**表内容*/
			for(int j=0;j<sr.size();j++){
				sb.append("<tr>\n");
				for(int i=0;i<md.getColumnCount();i++){
					sb.append("<td style='font-size:13'>");
					sb.append(sr.get(j, md.getColumnNameByIndex(i)));
					sb.append("</td>\n");
				}
				sb.append("</tr>\n");
			}
			sb.append("</talbe>");
		}
		return sb.toString();
	}

	/**
	 * 字符串加数字
	 * @param str 字符串
	 * @param addNum 数字
	 * @return 返回数字相加后的字符串
	 */
	public static String strAdd(String str,int addNum){
		if(str==null){
			return str;
		}else{
			return intToString(stringToInt(str)+addNum);
		}
	}

	/**
	 * 空检查
	 * @param checkStr 需要检查的字符串
	 * @param prompt 提示信息
	 * @throws ErrorMessage
	 */
	public static void checkNull(String checkStr,String prompt) throws ErrorMessage{
		if(checkStr==null || "".equals(checkStr.trim())){
			throw new ErrorMessage(prompt+" is null");
		}
	}

	/**
	 * 空检查
	 * @param checkStr 需要检查的字符串
	 * @param prompt 提示信息
	 * @throws ErrorMessage
	 */
	public static void checkNull(Object checkStr,String prompt) throws ErrorMessage{
		if(checkStr==null){
			throw new ErrorMessage(prompt+" is null");
		}
	}

	/**
	 * 字符串截位(字符串超长时使用)
	 * @param content 要截位的字符串
	 * @param maxLength 最大长度
	 * @return
	 */
	public static String getSubString(String content,int maxLength){
		if(content==null){
			return content;
		}

		byte bt[]=content.getBytes(); 
		if(bt.length>maxLength){
			if(maxLength>1)     {     
				if(bt[maxLength]<0)     {     
					content = new String(bt,0,--maxLength);   
				}else{     
					content = new String(bt,0,maxLength);     
				}     
			}else{     
				if(maxLength==1){     
					if(bt[maxLength]<0){     
						content = new String(bt,0,++maxLength);     
					}else{     
						content=new String(bt,0,maxLength);     
					}     
				}    
			}
		}
		return content;
	}

	/**
	 * 判断是否是类没找到异常
	 * @param e ErrorMessage异常对象
	 * @return true:是类没找到异常
	 */
	public static boolean isClassNotFound(ErrorMessage e){
		StringBuilder sb = new StringBuilder();
		e.getDescription(sb);
		if(sb!=null && sb.indexOf("java.lang.ClassNotFoundException")!=-1){
			return true;
		}else{
			return false;
		}
	}

	/**
	 * 字符串位数控制,超长截位、不够补齐
	 * @param str 需要控制的字符串
	 * @param length 字符串需要控制的长度
	 * @return 截位或补齐后的字符串
	 */
	public static String stringClip(String str,int length){
		if(str==null || "".equals(str.trim())){

		}
		if(str.length()>length){
			str =  str.substring(0, length);
		}else if(str.length()<length){
			StringBuilder sb = new StringBuilder();
			for(int i=0;i<(length-str.length());i++){
				sb.append("z");
			}
			str = str + sb.toString();
		}
		return str;
	}

	public static void deleteStringBuilderLast(StringBuilder sb){
		if(sb.length()>0){
			sb.deleteCharAt(sb.length()-1);
		}
	}

	public static void deleteStringBuilderLast(StringBuilder sb,int length){
		if(sb.length()>0){
			sb.delete(sb.length()-length,sb.length());
		}
	}

	/**
	 * 判断数字是否是奇数
	 * @param num 数字
	 * @return 是否是奇数 true:是 false:不是
	 */
	public static boolean isOdd(int num){
		boolean boo = true;
		if(num%2==0){
			boo = false;
		}
		return boo;
	}

	/**
	 * 返回子List,从start开始到end结束
	 * @param list    列表
	 * @param start   开始(包含)
	 * @param end     结束(不包含)
	 * @return 子List<BR>
	 * @throws ErrorMessage  如果下标越界
	 */
	public static ArrayList<String> subList(ArrayList<String> list,int start,int end) throws ErrorMessage{
		ArrayList<String> subList = new ArrayList<String>();
		if(list==null || list.size()<end || start>end)
			throw new ErrorMessage("Sub List out of bound List size is"+list.size()+" end is "+end+" !");
		for(int i=start;i<end;i++){
			subList.add(list.get(i));
		}
		return subList;
	}
	
	/**
	 * 从一个包含中文字符的字符串中，截取指定字符数量的字符串<BR>
	 * 确保最后一个是完整的中文字符
	 * @param sTxt			字符串
	 * @param lessChar		需要截取的字符数量
	 * @param fixChar		取最后一个字符,但对应的是一个中文字时，补齐的字符(可以是空字符串,不能是null)
	 * @return
	 */
	public static StringBuilder cutString(String sTxt,int lessChar,String fixChar){
		int bLen=sTxt.getBytes().length;
		StringBuilder sb = new StringBuilder();
		
		/**1.判断是否需要截位*/
		if(lessChar<bLen){//需要截位
			lessChar=lessChar-1;//减1留出一个省略号字符的宽度
			int i=0;
			for(char bb:sTxt.toCharArray()){
				if(bb<0||bb>255){//非Ascii字符
					if(lessChar-i==1){//如果剩余宽度是1,则不足以放入一个中文字符
						sb.append(fixChar);
					}else{
						sb.append(bb);
					}
					i+=2;
				}else{			//Ascii字符
					i+=1;
					sb.append(bb);
				}
				if(i>=lessChar)
					break;
			}
			sb.append('…');
		}else{
			sb.append(sTxt);
		}
		return sb;
	}
}
